﻿using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Is.Ex;
using Should.Fluent;

namespace Is.Test.Fluent
{
    [TestClass]
    public class HasExtensionsExTest
    {
        [TestMethod]
        public void Test_HasExisting()
        {
            ComplexObject complexObject = new ComplexObject(null, 0);
            #region //// Assert
            complexObject.Has().Existing(co => co.Object).Should().Be.False();
            complexObject.Has().Existing(co => co.Value).Should().Be.True();
            complexObject.Has().Existing(co => co.Object.Object).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.Value).Should().Be.False();
            complexObject.Has().Existing(co => co).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.Object).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.FieldObject).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.FieldObject.FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.FieldObject.Value).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetObject()).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().Value).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject()).Should().Be.False();
            complexObject.Has().Existing(co => co.GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().Object).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().FieldObject).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().FieldObject.FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().FieldObject.Value).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().GetObject()).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().GetObject()).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().GetObject().FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().GetObject().GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().GetObject().Value).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().Object.FieldObject.FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().Object.FieldObject.Value).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().Object.FieldObject.GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.GetObject().FieldObject.FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.GetObject().FieldObject.Value).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.GetObject().FieldObject.GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.FieldObject.GetObject().FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.FieldObject.GetObject().Value).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.FieldObject.GetObject().GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.Object.GetObject().FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.Object.GetObject().Value).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.Object.GetObject().GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().Object.FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().Object.Value).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().Object.GetValue()).Should().Be.False();
            #endregion

            ComplexObject nullObject = null;
            #region //// Assert

            nullObject.Has().Existing(co => co.Object).Should().Be.False();
            nullObject.Has().Existing(co => co.Value).Should().Be.False();
            nullObject.Has().Existing(co => co.Object.Object).Should().Be.False();
            nullObject.Has().Existing(co => co.Object.Value).Should().Be.False();
            nullObject.Has().Existing(co => co).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldObject).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldValue).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldObject.Object).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldObject.FieldObject).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldObject.FieldValue).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldObject.FieldObject.FieldValue).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldObject.FieldObject.Value).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldObject.GetObject()).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldObject.GetValue()).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldObject.GetObject().FieldValue).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldObject.GetObject().GetValue()).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldObject.GetObject().Value).Should().Be.False();
            nullObject.Has().Existing(co => co.GetObject()).Should().Be.False();
            nullObject.Has().Existing(co => co.GetValue()).Should().Be.False();
            nullObject.Has().Existing(co => co.GetObject().Object).Should().Be.False();
            nullObject.Has().Existing(co => co.GetObject().FieldObject).Should().Be.False();
            nullObject.Has().Existing(co => co.GetObject().FieldValue).Should().Be.False();
            nullObject.Has().Existing(co => co.GetObject().FieldObject.FieldValue).Should().Be.False();
            nullObject.Has().Existing(co => co.GetObject().FieldObject.Value).Should().Be.False();
            nullObject.Has().Existing(co => co.GetObject().GetObject()).Should().Be.False();
            nullObject.Has().Existing(co => co.GetObject().GetObject()).Should().Be.False();
            nullObject.Has().Existing(co => co.GetObject().GetValue()).Should().Be.False();
            nullObject.Has().Existing(co => co.GetObject().FieldValue).Should().Be.False();
            nullObject.Has().Existing(co => co.GetObject().GetObject().FieldValue).Should().Be.False();
            nullObject.Has().Existing(co => co.GetObject().GetObject().GetValue()).Should().Be.False();
            nullObject.Has().Existing(co => co.GetObject().GetObject().Value).Should().Be.False();
            nullObject.Has().Existing(co => co.GetObject().Object.FieldObject.FieldValue).Should().Be.False();
            nullObject.Has().Existing(co => co.GetObject().Object.FieldObject.Value).Should().Be.False();
            nullObject.Has().Existing(co => co.GetObject().Object.FieldObject.GetValue()).Should().Be.False();
            nullObject.Has().Existing(co => co.Object.GetObject().FieldObject.FieldValue).Should().Be.False();
            nullObject.Has().Existing(co => co.Object.GetObject().FieldObject.Value).Should().Be.False();
            nullObject.Has().Existing(co => co.Object.GetObject().FieldObject.GetValue()).Should().Be.False();
            nullObject.Has().Existing(co => co.Object.FieldObject.GetObject().FieldValue).Should().Be.False();
            nullObject.Has().Existing(co => co.Object.FieldObject.GetObject().Value).Should().Be.False();
            nullObject.Has().Existing(co => co.Object.FieldObject.GetObject().GetValue()).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldObject.Object.GetObject().FieldValue).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldObject.Object.GetObject().Value).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldObject.Object.GetObject().GetValue()).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldObject.GetObject().Object.FieldValue).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldObject.GetObject().Object.Value).Should().Be.False();
            nullObject.Has().Existing(co => co.FieldObject.GetObject().Object.GetValue()).Should().Be.False();

            #endregion

            complexObject = new ComplexObject(new ComplexObject(null, 1), 0);
            #region //// Assert

            complexObject.Has().Existing(co => co.Object).Should().Be.True();
            complexObject.Has().Existing(co => co.Value).Should().Be.True();
            complexObject.Has().Existing(co => co.Object.Object).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.Value).Should().Be.True();
            complexObject.Has().Existing(co => co).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.Object).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.FieldObject).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.FieldObject.FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.FieldObject.Value).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetObject()).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().Value).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject()).Should().Be.True();
            complexObject.Has().Existing(co => co.GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().Object).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().FieldObject).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().FieldObject.FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().FieldObject.Value).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().GetObject()).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().GetObject()).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().GetObject().FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().GetObject().GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().GetObject().Value).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().Object.FieldObject.FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().Object.FieldObject.Value).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().Object.FieldObject.GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.GetObject().FieldObject.FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.GetObject().FieldObject.Value).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.GetObject().FieldObject.GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.FieldObject.GetObject().FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.FieldObject.GetObject().Value).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.FieldObject.GetObject().GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.Object.GetObject().FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.Object.GetObject().Value).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.Object.GetObject().GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().Object.FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().Object.Value).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().Object.GetValue()).Should().Be.False();

            #endregion

            complexObject = new ComplexObject(new ComplexObject(new ComplexObject(null, 2), 1), 0);
            #region //// Assert

            complexObject.Has().Existing(co => co.Object).Should().Be.True();
            complexObject.Has().Existing(co => co.Value).Should().Be.True();
            complexObject.Has().Existing(co => co.Object.Object).Should().Be.True();
            complexObject.Has().Existing(co => co.Object.Value).Should().Be.True();
            complexObject.Has().Existing(co => co).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.Object).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.FieldObject).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.FieldObject.FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.FieldObject.Value).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.GetObject()).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().Value).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject()).Should().Be.True();
            complexObject.Has().Existing(co => co.GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().Object).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().FieldObject).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().FieldObject.FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().FieldObject.Value).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().GetObject()).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().GetObject()).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().GetObject().FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().GetObject().GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().GetObject().Value).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().Object.FieldObject.FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().Object.FieldObject.Value).Should().Be.False();
            complexObject.Has().Existing(co => co.GetObject().Object.FieldObject.GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.GetObject().FieldObject.FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.GetObject().FieldObject.Value).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.GetObject().FieldObject.GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.FieldObject.GetObject().FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.FieldObject.GetObject().Value).Should().Be.False();
            complexObject.Has().Existing(co => co.Object.FieldObject.GetObject().GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.Object.GetObject().FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.Object.GetObject().Value).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.Object.GetObject().GetValue()).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().Object.FieldValue).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().Object.Value).Should().Be.False();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().Object.GetValue()).Should().Be.False();

            #endregion

            complexObject = new ComplexObject(new ComplexObject(new ComplexObject(new ComplexObject(null, 3), 2), 1), 0);
            #region //// Assert

            complexObject.Has().Existing(co => co.Object).Should().Be.True();
            complexObject.Has().Existing(co => co.Value).Should().Be.True();
            complexObject.Has().Existing(co => co.Object.Object).Should().Be.True();
            complexObject.Has().Existing(co => co.Object.Value).Should().Be.True();
            complexObject.Has().Existing(co => co).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.Object).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.FieldObject).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.FieldObject.FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.FieldObject.Value).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.GetObject()).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().Value).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject()).Should().Be.True();
            complexObject.Has().Existing(co => co.GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().Object).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().FieldObject).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().FieldObject.FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().FieldObject.Value).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().GetObject()).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().GetObject()).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().GetObject().FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().GetObject().GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().GetObject().Value).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().Object.FieldObject.FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().Object.FieldObject.Value).Should().Be.True();
            complexObject.Has().Existing(co => co.GetObject().Object.FieldObject.GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.Object.GetObject().FieldObject.FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.Object.GetObject().FieldObject.Value).Should().Be.True();
            complexObject.Has().Existing(co => co.Object.GetObject().FieldObject.GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.Object.FieldObject.GetObject().FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.Object.FieldObject.GetObject().Value).Should().Be.True();
            complexObject.Has().Existing(co => co.Object.FieldObject.GetObject().GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.Object.GetObject().FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.Object.GetObject().Value).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.Object.GetObject().GetValue()).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().Object.FieldValue).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().Object.Value).Should().Be.True();
            complexObject.Has().Existing(co => co.FieldObject.GetObject().Object.GetValue()).Should().Be.True();

            #endregion

            Should.Core.Assertions.Assert.Throws<ArgumentNullException>(() => complexObject.Has().Existing(null));
            Should.Core.Assertions.Assert.Throws<ArgumentNullException>(() => nullObject.Has().Existing(null));

        }

        [TestMethod]
        public void Test_HasExistWithValue()
        {
            ComplexObject complexObject = new ComplexObject(null, 0);
            #region //// Assert

            complexObject.Has().ExistingWithValue(co => co.Value, 0).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object, null).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Value, 0).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object.Object, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.Value, 0).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co, complexObject).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldValue, 0).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject, null).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldValue, 0).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject(), null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetValue(), 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetValue(), 0).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().GetValue(), 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject(), null).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetValue(), 0).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetValue(), 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 0).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject(), null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject(), null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetValue(), 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetValue(), 0).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 0).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().GetValue(), 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.FieldValue, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.Value, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.GetValue(), 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.FieldValue, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.Value, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.GetValue(), 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().FieldValue, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().Value, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().GetValue(), 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().FieldValue, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().Value, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().GetValue(), 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.FieldValue, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.Value, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.GetValue(), 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.GetValue(), 2).Should().Be.False();

            #endregion

            ComplexObject nullObject = null;
            #region //// Assert
            nullObject.Has().ExistingWithValue(co => co, nullObject).Should().Be.True();
            nullObject.Has().ExistingWithValue(co => co, complexObject).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co, null).Should().Be.True();
            nullObject.Has().ExistingWithValue(co => co.Value, 0).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.Object, null).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.Value, 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.Object.Object, null).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.Object.Value, 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.Object.Value, 0).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldValue, 0).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldValue, 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldValue, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject, null).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.Object, null).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject, null).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.FieldValue, 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.FieldValue, 0).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.FieldValue, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.FieldValue, 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.Value, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.Value, 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.GetObject(), null).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.GetValue(), 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.GetValue(), 0).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().FieldValue, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().FieldValue, 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().GetValue(), 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().GetValue(), 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Value, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Value, 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject(), null).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetValue(), 0).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetValue(), 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetValue(), 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().Object, null).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().FieldObject, null).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 0).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.FieldValue, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.FieldValue, 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.Value, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.Value, 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().GetObject(), null).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().GetObject(), null).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().GetValue(), 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().GetValue(), 0).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 0).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().GetObject().FieldValue, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().GetObject().FieldValue, 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().GetObject().GetValue(), 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().GetObject().GetValue(), 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().GetObject().Value, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().GetObject().Value, 1).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.FieldValue, 3).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.Value, 3).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.GetValue(), 3).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.FieldValue, 3).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.Value, 3).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.GetValue(), 3).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().FieldValue, 3).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().Value, 3).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().GetValue(), 3).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().FieldValue, 3).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().Value, 3).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().GetValue(), 3).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.FieldValue, 3).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.Value, 3).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.GetValue(), 3).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.FieldValue, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.Value, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.GetValue(), 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.FieldValue, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.Value, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.GetValue(), 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().FieldValue, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().Value, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().GetValue(), 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().FieldValue, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().Value, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().GetValue(), 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.FieldValue, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.Value, 2).Should().Be.False();
            nullObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.GetValue(), 2).Should().Be.False();

            #endregion

            ComplexObject complexObject2 = new ComplexObject(null, 1);
            complexObject = new ComplexObject(complexObject2, 0);
            #region //// Assert
            complexObject.Has().ExistingWithValue(co => co, nullObject).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co, complexObject).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Value, 0).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object, complexObject2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.Object, null).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object.Value, 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object.Value, 0).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldValue, 0).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject, complexObject2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object, null).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject, null).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldValue, 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject(), null).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetValue(), 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetValue(), 0).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().GetValue(), 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject(), null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject(), complexObject2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetValue(), 0).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetValue(), 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object, null).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject, null).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject(), null).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject(), null).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetValue(), 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().GetValue(), 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.FieldValue, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.Value, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.GetValue(), 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.FieldValue, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.Value, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.GetValue(), 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().FieldValue, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().Value, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().GetValue(), 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().FieldValue, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().Value, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().GetValue(), 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.FieldValue, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.Value, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.GetValue(), 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.GetValue(), 2).Should().Be.False();

            #endregion

            ComplexObject complexObject3 = new ComplexObject(null, 2);
            complexObject2 = new ComplexObject(complexObject3, 1);
            complexObject = new ComplexObject(complexObject2, 0);
            #region //// Assert
            complexObject.Has().ExistingWithValue(co => co, nullObject).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co, complexObject).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Value, 0).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object, complexObject2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.Object, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.Object, complexObject3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object.Value, 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object.Value, 0).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldValue, 0).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject, complexObject2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object, complexObject3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject, complexObject3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldValue, 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldValue, 0).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.FieldValue, 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.Value, 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject(), null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject(), complexObject3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetValue(), 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetValue(), 0).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().FieldValue, 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().GetValue(), 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().GetValue(), 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Value, 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject(), null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject(), complexObject2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetValue(), 0).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetValue(), 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object, complexObject3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject, complexObject3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.FieldValue, 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.Value, 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject(), null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject(), complexObject3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetValue(), 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().FieldValue, 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().GetValue(), 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().GetValue(), 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().Value, 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.FieldValue, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.Value, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.GetValue(), 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.FieldValue, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.Value, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.GetValue(), 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().FieldValue, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().Value, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().GetValue(), 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().FieldValue, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().Value, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().GetValue(), 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.FieldValue, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.Value, 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.GetValue(), 3).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.GetValue(), 2).Should().Be.False();

            #endregion

            ComplexObject complexObject4 = new ComplexObject(null, 3);
            complexObject3 = new ComplexObject(complexObject4, 2);
            complexObject2 = new ComplexObject(complexObject3, 1);
            complexObject = new ComplexObject(complexObject2, 0);
            #region //// Assert
            complexObject.Has().ExistingWithValue(co => co, nullObject).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co, complexObject).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Value, 0).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object, complexObject2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.Object, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.Object, complexObject3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object.Value, 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object.Value, 0).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldValue, 0).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject, complexObject2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object, complexObject3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject, complexObject3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldValue, 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.FieldValue, 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.Value, 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.FieldObject.Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject(), null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject(), complexObject3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetValue(), 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().FieldValue, 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().GetValue(), 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().GetValue(), 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Value, 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject(), null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject(), complexObject2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetValue(), 0).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetValue(), 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object, complexObject3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject, complexObject3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 0).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.FieldValue, 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.Value, 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldObject.Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject(), null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject(), complexObject3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetValue(), 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 1).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().FieldValue, 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().FieldValue, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().GetValue(), 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().GetValue(), 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().Value, 2).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().GetObject().Value, 1).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject, complexObject4).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.FieldValue, 3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.Value, 3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.GetValue(), 3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject, null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject, complexObject4).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.FieldValue, 3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.Value, 3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.GetValue(), 3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject(), null).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject(), complexObject4).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().FieldValue, 3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().Value, 3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().GetValue(), 3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().FieldValue, 3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().Value, 3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().GetValue(), 3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.FieldValue, 3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.Value, 3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.GetValue(), 3).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.GetObject().Object.FieldObject.GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.GetObject().FieldObject.GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.Object.FieldObject.GetObject().GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.Object.GetObject().GetValue(), 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.FieldValue, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.Value, 2).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.FieldObject.GetObject().Object.GetValue(), 2).Should().Be.False();

            #endregion

            Should.Core.Assertions.Assert.Throws<ArgumentNullException>(() => complexObject.Has().ExistingWithValue(null, 1));
            Should.Core.Assertions.Assert.Throws<ArgumentNullException>(() => nullObject.Has().ExistingWithValue(null, 1));

            complexObject4 = new ComplexObject(null, 3, null);
            complexObject3 = new ComplexObject(complexObject4, 2, false);
            complexObject2 = new ComplexObject(complexObject3, 1, null);
            complexObject = new ComplexObject(complexObject2, 0, true);
            #region //// Assert

            complexObject.Has().ExistingWithValue(co => co.BoolValue, true).Should().Be.True();
            complexObject.Has().ExistingWithValue(co => co.BoolValue, false).Should().Be.False();
            complexObject.Has().ExistingWithValue(co => co.BoolValue, null).Should().Be.False();



            #endregion
        }

    }
}
